/**
 * 文件监控器
 * 负责监控文件变化并触发自动同步
 * 
 * @author lihengtt <lihengsir@gmail.com>
 * @github https://github.com/lihengtt
 */

import * as vscode from 'vscode';
import * as chokidar from 'chokidar';
import * as path from 'path';
import { ConfigManager } from './configManager';
import { DeploymentManager } from './deploymentManager';
import { LogManager } from './logManager';

export class FileWatcher {
    private configManager: ConfigManager;
    private deploymentManager: DeploymentManager;
    private watcher: chokidar.FSWatcher | null = null;
    private syncQueue: Array<{filePath: string, event: string, timestamp: number, retryCount: number}> = [];
    private syncTimer: NodeJS.Timeout | null = null;
    private watching: boolean = false;
    private logger: LogManager;
    private maxRetries: number = 3;
    private configWatcher: vscode.FileSystemWatcher | null = null;
    
    // 性能限制配置
    private readonly MAX_WATCHED_FILES = 5000; // 最大监控文件数量
    private readonly MAX_WATCH_DEPTH = 10; // 最大监控深度
    private readonly LARGE_PROJECT_THRESHOLD = 10000; // 大项目文件数阈值
    private readonly DEBOUNCE_DELAY = 300; // 防抖延迟（毫秒）
    private readonly MAX_SYNC_QUEUE_SIZE = 100; // 最大同步队列大小
    
    // 性能监控
    private watchedFileCount: number = 0;
    private isLargeProject: boolean = false;
    private debounceTimer: NodeJS.Timeout | null = null;
    private memoryCheckInterval: NodeJS.Timeout | null = null;
    private lastMemoryCheck: number = 0;

    /**
     * 构造函数
     * @param configManager - 配置管理器实例
     * @param deploymentManager - 部署管理器实例
     * @author lihengtt <lihengsir@gmail.com>
     */
    constructor(configManager: ConfigManager, deploymentManager: DeploymentManager) {
        this.configManager = configManager;
        this.deploymentManager = deploymentManager;
        this.logger = LogManager.getInstance();
        
        // 监听配置变化
        this.setupConfigWatcher();
    }
    
    /**
     * 设置配置监听器
     * @author lihengtt <lihengsir@gmail.com>
     */
    private setupConfigWatcher(): void {
        // 清理现有的配置监听器
        if (this.configWatcher) {
            this.configWatcher.dispose();
        }
        
        // 监听工作区配置文件变化
        this.configWatcher = vscode.workspace.createFileSystemWatcher('**/.rsync-deployment.json');
        
        this.configWatcher.onDidChange(() => {
            this.logger.info('检测到配置文件变化，重新加载监控设置', 'FileWatcher');
            this.reloadConfig();
        });
        
        this.configWatcher.onDidCreate(() => {
            this.logger.info('检测到配置文件创建，启动监控设置', 'FileWatcher');
            this.reloadConfig();
        });
        
        this.configWatcher.onDidDelete(() => {
            this.logger.info('检测到配置文件删除，停止监控', 'FileWatcher');
            this.stop();
        });
    }

    /**
     * 启动文件监控
     * @author lihengtt <lihengsir@gmail.com>
     */
    async start(): Promise<void> {
        if (this.watcher) {
            this.logger.warn('文件监控已经在运行', 'FileWatcher');
            return;
        }

        const config = this.configManager.getConfig();
        if (!config) {
            this.logger.error('无法启动文件监控：配置不存在', 'FileWatcher');
            return;
        }

        try {
            // 检查项目大小
            this.checkProjectSize(config.localPath);
            
            // 如果是大项目，自动降级为手动模式或询问用户
            if (this.isLargeProject) {
                const choice = await vscode.window.showWarningMessage(
                    `检测到大型项目（超过${this.LARGE_PROJECT_THRESHOLD}个文件），启用自动同步可能影响系统性能和VSCode搜索功能。\n\n建议使用手动同步模式以获得更好的性能体验。`,
                    { modal: true },
                    '强制启用自动同步',
                    '使用手动模式（推荐）'
                );
                
                if (choice === '使用手动模式（推荐）' || !choice) {
                    this.logger.info('大项目自动降级为手动模式', 'FileWatcher');
                    vscode.window.showInformationMessage('已切换到手动同步模式，您可以使用"同步所有"按钮进行文件同步。');
                    return;
                } else {
                    this.logger.warn('用户强制在大项目中启用自动同步', 'FileWatcher');
                    vscode.window.showWarningMessage('已强制启用自动同步，如遇到性能问题请及时关闭。');
                }
            }
            
            this.logger.info(`开始监控文件变化: ${config.localPath}`, 'FileWatcher');
            this.logger.info(`监控深度限制: ${this.MAX_WATCH_DEPTH}, 文件数量限制: ${this.MAX_WATCHED_FILES}`, 'FileWatcher');
            
            // 重置计数器
            this.watchedFileCount = 0;
            
            // 构建排除模式
            const excludePatterns = this.buildExcludePatterns(config.excludeRules || []);
            
            // 创建文件监控器
            this.watcher = chokidar.watch(config.localPath, {
                ignored: (path: string) => {
                    return excludePatterns.some(pattern => {
                        if (pattern instanceof RegExp) {
                            return pattern.test(path);
                        }
                        return path.includes(pattern);
                    });
                },
                persistent: true,
                ignoreInitial: true,
                followSymlinks: false,
                depth: this.MAX_WATCH_DEPTH, // 限制监控深度
                awaitWriteFinish: {
                    stabilityThreshold: 100, // 减少稳定性阈值
                    pollInterval: 50
                },
                usePolling: false, // 使用原生文件系统事件
                interval: 1000, // 轮询间隔（仅在usePolling为true时使用）
                binaryInterval: 2000 // 二进制文件轮询间隔
            });

            // 启动内存监控
            this.startMemoryMonitoring();
            
            // 监控文件数量
            this.watcher.on('add', (filePath) => {
                this.watchedFileCount++;
                if (this.watchedFileCount > this.MAX_WATCHED_FILES) {
                    this.logger.warn(`监控文件数量超过限制(${this.MAX_WATCHED_FILES})，停止监控以保护系统性能`, 'FileWatcher');
                    vscode.window.showWarningMessage('监控文件数量过多，已自动停止文件监控以保护系统性能');
                    this.stop();
                    return;
                }
                this.onFileChange('add', filePath);
            });
            
            this.watcher.on('change', (filePath) => this.onFileChange('change', filePath));
            this.watcher.on('unlink', (filePath) => {
                this.watchedFileCount = Math.max(0, this.watchedFileCount - 1);
                this.onFileChange('unlink', filePath);
            });

            this.watcher.on('error', (error) => {
                console.error('文件监控错误:', error);
                const errorMessage = error instanceof Error ? error.message : String(error);
                this.logger.error(`文件监控错误: ${errorMessage}`, 'FileWatcher');
                vscode.window.showErrorMessage(`文件监控错误: ${errorMessage}`);
                
                // 如果是资源相关错误，自动停止监控
                if (errorMessage.includes('EMFILE') || errorMessage.includes('ENFILE') || errorMessage.includes('EBADF')) {
                    this.logger.warn('检测到系统资源错误，自动停止文件监控', 'FileWatcher');
                    this.stop();
                }
            });

            this.watching = true;
            this.watchedFileCount = 0; // 重置计数器
            this.logger.info(`文件自动同步已启用，监控深度限制: ${this.MAX_WATCH_DEPTH}层，文件数量限制: ${this.MAX_WATCHED_FILES}个`, 'FileWatcher');
            vscode.window.showInformationMessage('文件自动同步已启用');
        } catch (error) {
            console.error('启动文件监控失败:', error);
            this.logger.error('启动文件监控失败:','FileWatcher',error);
            vscode.window.showErrorMessage(`启动文件监控失败: ${error}`);
        }
    }

    /**
     * 停止文件监控
     * 清理所有资源，避免内存泄漏和与其他插件冲突
     * @author lihengtt <lihengsir@gmail.com>
     */
    stop(): void {
        // 清理文件监控器
        if (this.watcher) {
            this.watcher.close();
            this.watcher = null;
        }

        // 清理同步定时器
        if (this.syncTimer) {
            clearTimeout(this.syncTimer);
            this.syncTimer = null;
        }
        
        // 清理防抖定时器
        if (this.debounceTimer) {
            clearTimeout(this.debounceTimer);
            this.debounceTimer = null;
        }
        
        // 清理内存检查定时器
        if (this.memoryCheckInterval) {
            clearInterval(this.memoryCheckInterval);
            this.memoryCheckInterval = null;
        }
        
        // 清理配置文件监听器
        if (this.configWatcher) {
            this.configWatcher.dispose();
            this.configWatcher = null;
        }

        // 清理同步队列和重置计数器
        this.syncQueue = [];
        this.watchedFileCount = 0;
        this.watching = false;
        this.isLargeProject = false;
        
        this.logger.info('文件监控已停止，所有资源已清理', 'FileWatcher');
        vscode.window.showInformationMessage('文件自动同步已停用');
    }

    /**
     * 切换监控状态
     * @author lihengtt <lihengsir@gmail.com>
     */
    toggle(): void {
        const previousState = this.watching;
        this.logger.info(`[TOGGLE] 开始切换文件监控状态，当前状态: ${previousState ? '监控中' : '已停止'}`, 'FileWatcher');
        
        try {
            if (this.watching) {
                this.logger.info('[TOGGLE] 执行停止监控操作', 'FileWatcher');
                this.stop();
            } else {
                this.logger.info('[TOGGLE] 执行启动监控操作', 'FileWatcher');
                this.start();
            }
            
            const newState = this.watching;
            this.logger.info(`[TOGGLE] 文件监控状态切换完成: ${previousState ? '监控中' : '已停止'} -> ${newState ? '监控中' : '已停止'}`, 'FileWatcher');
            
            // 验证状态是否正确切换
            if (previousState === newState) {
                this.logger.warn(`[TOGGLE] 警告：状态切换可能失败，前后状态相同: ${newState}`, 'FileWatcher');
            }
        } catch (error) {
            this.logger.error(`[TOGGLE] 切换文件监控状态时发生错误: ${error}`, 'FileWatcher');
            throw error;
        }
    }

    /**
     * 获取监控状态
     * @returns boolean
     */
    isWatching(): boolean {
        return this.watching;
    }

    /**
     * 处理文件变化事件
     * @param event - 文件变化事件类型
     * @param filePath - 文件路径
     * @author lihengtt <lihengsir@gmail.com>
     */
    private onFileChange(event: string, filePath: string): void {
        const config = this.configManager.getConfig();
        if (!config) {
            return;
        }

        // 检查同步队列大小，防止内存溢出
        if (this.syncQueue.length >= this.MAX_SYNC_QUEUE_SIZE) {
            this.logger.warn(`同步队列已满(${this.MAX_SYNC_QUEUE_SIZE})，跳过文件变化事件: ${filePath}`, 'FileWatcher');
            return;
        }

        // 规范化文件路径
        const normalizedFilePath = path.resolve(filePath);
        const normalizedLocalPath = path.resolve(config.localPath);

        // 检查文件是否应该被排除
        const excludePatterns = this.buildExcludePatterns(config.excludeRules || []);
        const relativePath = path.relative(normalizedLocalPath, normalizedFilePath);
        
        for (const pattern of excludePatterns) {
            if (typeof pattern === 'string' ? relativePath.includes(pattern) : pattern.test(relativePath)) {
                this.logger.debug(`文件被排除: ${normalizedFilePath}`, 'FileWatcher');
                return;
            }
        }

        // 添加到同步队列
        this.syncQueue.push({
            filePath: normalizedFilePath,
            event,
            timestamp: Date.now(),
            retryCount: 0
        });
        
        this.logger.info(`文件变化检测: ${normalizedFilePath} - ${event}`, 'FileWatcher');

        // 使用防抖机制，减少频繁的同步操作
        if (this.debounceTimer) {
            clearTimeout(this.debounceTimer);
        }

        this.debounceTimer = setTimeout(() => {
            this.processSyncQueue();
        }, this.DEBOUNCE_DELAY);
    }

    /**
     * 处理同步队列
     * @author lihengtt <lihengsir@gmail.com>
     */
    private async processSyncQueue(): Promise<void> {
        if (this.syncQueue.length === 0) {
            return;
        }

        // 显示状态栏消息
        const statusMessage = vscode.window.setStatusBarMessage(`Rsync: 同步 ${this.syncQueue.length} 个文件...`);

        try {
            // 复制队列并清空原队列
            const queue = [...this.syncQueue];
            this.syncQueue = [];

            // 按文件路径去重，保留最新的事件（但保留重试信息）
            const uniqueFiles = new Map<string, { event: string, filePath: string, retryCount: number, timestamp: number }>();
            for (const item of queue) {
                const existing = uniqueFiles.get(item.filePath);
                if (!existing || item.timestamp > existing.timestamp || 
                    (item.event === 'retry' && existing.event !== 'retry')) {
                    uniqueFiles.set(item.filePath, { event: item.event, filePath: item.filePath, retryCount: item.retryCount, timestamp: item.timestamp });
                }
            }
            
            this.logger.info(`开始处理同步队列，共${uniqueFiles.size}个文件`, 'FileWatcher');

            // 处理每个文件
            for (const [index, item] of Array.from(uniqueFiles.values()).entries()) {
                // 更新状态栏消息
                statusMessage.dispose();
                const progress = Math.round(((index + 1) / uniqueFiles.size) * 100);
                vscode.window.setStatusBarMessage(`Rsync: 同步文件 ${index + 1}/${uniqueFiles.size} (${progress}%)`);

                // 如果是删除事件，暂时不处理（rsync会自动处理）
                if (item.event === 'unlink' || item.event === 'unlinkDir') {
                    this.logger.info(`文件已删除，将在下次完整同步时处理: ${item.filePath}`, 'FileWatcher');
                    continue;
                }

                // 同步文件 - 自动执行，无需用户确认
                await this.syncFileWithRetry(item.filePath, item.retryCount);
            }
        } finally {
            // 清除状态栏消息
            statusMessage.dispose();
            vscode.window.setStatusBarMessage(`Rsync: 同步完成`, 3000);
        }
    }

    /**
     * 构建排除模式
     * @param excludeRules - 排除规则
     * @returns RegExp | string[]
     * @author lihengtt <lihengsir@gmail.com>
     */
    private buildExcludePatterns(excludeRules: string[]): (string | RegExp)[] {
        const patterns: (string | RegExp)[] = [];
        
        // 默认排除模式 - 扩展更多常见的不需要同步的文件和目录
        patterns.push(
            // 版本控制
            /node_modules/,
            /\.git/,
            /\.svn/,
            /\.hg/,
            
            // IDE和编辑器
            /\.vscode/,
            /\.idea/,
            /\.sublime-/,
            
            // 系统文件
            /\.DS_Store/,
            /Thumbs\.db/,
            /desktop\.ini/,
            
            // 构建和缓存目录
            /dist/,
            /build/,
            /out/,
            /\.next/,
            /\.nuxt/,
            /\.cache/,
            /\.temp/,
            /\.tmp/,
            
            // 日志文件
            /\.log$/,
            /logs/,
            
            // 包管理器
            /package-lock\.json/,
            /yarn\.lock/,
            /pnpm-lock\.yaml/,
            
            // 环境和配置
            /\.env/,
            /\.env\./,
            /\.rsync-deployment\.json/,
            
            // 媒体文件（通常较大且不需要频繁同步）
            /\.(mp4|avi|mov|wmv|flv|webm)$/i,
            /\.(mp3|wav|flac|aac|ogg)$/i,
            /\.(zip|rar|7z|tar|gz|bz2)$/i,
            
            // 临时文件
            /~$/,
            /\.swp$/,
            /\.swo$/,
            /\.tmp$/
        );
        
        // 用户自定义排除规则
        excludeRules.forEach(rule => {
            if (rule.includes('*')) {
                // 转换glob模式为正则表达式
                const regexPattern = rule
                    .replace(/\./g, '\\.')
                    .replace(/\*/g, '.*')
                    .replace(/\?/g, '.');
                patterns.push(new RegExp(regexPattern));
            } else {
                patterns.push(rule);
            }
        });
        
        return patterns;
    }

    /**
     * 带重试机制的文件同步
     * @param filePath - 文件路径
     * @param currentRetryCount - 当前重试次数
     * @author lihengtt <lihengsir@gmail.com>
     */
    private async syncFileWithRetry(filePath: string, currentRetryCount: number = 0): Promise<void> {
        const config = this.configManager.getConfig();
        if (!config) {
            this.logger.error('配置文件不存在，无法同步文件', 'FileWatcher');
            return;
        }

        try {
            this.logger.info(`自动同步文件 (尝试 ${currentRetryCount + 1}/${this.maxRetries + 1}): ${filePath}`, 'FileWatcher');
            
            // 添加详细的路径调试日志
            this.logger.info(`[DEBUG] 同步文件路径: ${filePath}`, 'FileWatcher');
            this.logger.info(`[DEBUG] 配置本地路径: ${config.localPath}`, 'FileWatcher');
            this.logger.info(`[DEBUG] 配置远程路径: ${config.remotePath}`, 'FileWatcher');
            
            // 规范化路径
            const normalizedFilePath = path.resolve(filePath);
            const normalizedLocalPath = path.resolve(config.localPath);
            
            this.logger.info(`[DEBUG] 规范化文件路径: ${normalizedFilePath}`, 'FileWatcher');
            this.logger.info(`[DEBUG] 规范化本地路径: ${normalizedLocalPath}`, 'FileWatcher');
            
            // 计算相对路径和远程路径
            const relativePath = path.relative(normalizedLocalPath, normalizedFilePath);
            const remotePath = path.posix.join(config.remotePath, relativePath.replace(/\\/g, '/'));
            
            this.logger.info(`[DEBUG] 计算相对路径: ${relativePath}`, 'FileWatcher');
            this.logger.info(`[DEBUG] 计算远程路径: ${remotePath}`, 'FileWatcher');
            
            // 使用DeploymentManager进行同步
            const success = await this.deploymentManager.uploadFile(normalizedFilePath, remotePath);
            
            if (success) {
                this.logger.info(`文件同步成功: ${normalizedFilePath}`, 'FileWatcher');
                vscode.window.showInformationMessage(`自动同步成功: ${path.basename(normalizedFilePath)}`, { modal: false });
            } else {
                throw new Error('文件上传失败');
            }
        } catch (error) {
            const errorMessage = error instanceof Error ? error.message : String(error);
            this.logger.error(`文件同步失败 (尝试 ${currentRetryCount + 1}/${this.maxRetries + 1}): ${filePath} - ${errorMessage}`, 'FileWatcher');
            
            // 如果还有重试次数，则重新加入队列
            if (currentRetryCount < this.maxRetries) {
                this.logger.warn(`将在3秒后重试同步文件: ${filePath}`, 'FileWatcher');
                
                setTimeout(() => {
                    this.syncQueue.push({
                        filePath,
                        event: 'retry',
                        timestamp: Date.now(),
                        retryCount: currentRetryCount + 1
                    });
                    
                    // 触发队列处理
                    if (this.syncTimer) {
                        clearTimeout(this.syncTimer);
                    }
                    this.syncTimer = setTimeout(() => {
                        this.processSyncQueue();
                    }, 1000);
                }, 3000);
            } else {
                // 重试次数用完，显示错误通知
                this.logger.error(`文件同步最终失败，已达到最大重试次数: ${filePath}`, 'FileWatcher');
                vscode.window.showErrorMessage(
                    `自动同步失败: ${path.basename(filePath)} - ${errorMessage}`,
                    '查看日志'
                ).then(selection => {
                    if (selection === '查看日志') {
                        this.logger.show();
                    }
                });
            }
        }
    }

    /**
     * 手动触发文件同步
     * @param filePath - 文件路径
     * @author lihengtt <lihengsir@gmail.com>
     */
    async syncFile(filePath: string): Promise<void> {
        try {
            const config = this.configManager.getConfig();
            if (!config) {
                throw new Error('配置文件不存在');
            }
            
            // 计算相对路径和远程路径
            const relativePath = path.relative(config.localPath, filePath);
            const remotePath = path.posix.join(config.remotePath, relativePath.replace(/\\/g, '/'));
            
            // 使用DeploymentManager进行同步
            const success = await this.deploymentManager.uploadFile(filePath, remotePath);
            
            if (success) {
                this.logger.info(`手动同步成功: ${filePath}`, 'FileWatcher');
                vscode.window.showInformationMessage(`文件同步成功: ${path.basename(filePath)}`);
            } else {
                throw new Error('文件上传失败');
            }
        } catch (error) {
            const errorMessage = error instanceof Error ? error.message : String(error);
            this.logger.error(`手动同步失败: ${filePath} - ${errorMessage}`, 'FileWatcher');
            vscode.window.showErrorMessage(`文件同步失败: ${errorMessage}`);
        }
    }

    /**
     * 重新加载配置
     * @author lihengtt <lihengsir@gmail.com>
     */
    reloadConfig(): void {
        const config = this.configManager.getConfig();
        
        if (config && config.autoSync) {
            // 配置存在且启用自动同步
            if (!this.watching) {
                this.logger.info('配置已启用自动同步，启动文件监控', 'FileWatcher');
                this.start();
            } else {
                // 重新启动以应用新配置
                this.logger.info('重新应用配置，重启文件监控', 'FileWatcher');
                this.stop();
                this.start();
            }
        } else {
            // 配置不存在或未启用自动同步
            if (this.watching) {
                this.logger.info('配置已禁用自动同步，停止文件监控', 'FileWatcher');
                this.stop();
            }
        }
    }

    /**
     * 开始监控（别名方法）
     */
    startWatching(): void {
        this.start();
    }

    /**
     * 更新监控状态
     */
    updateWatchState(): void {
        const config = this.configManager.getConfig();
        if (config?.autoSync && !this.watching) {
            this.start();
        } else if (!config?.autoSync && this.watching) {
            this.stop();
        }
    }

    /**
     * 切换监控状态（别名方法）
     */
    async toggleWatching(): Promise<void> {
        this.toggle();
    }
    
    /**
     * 检查项目大小
     * @param projectPath - 项目路径
     * @author lihengtt <lihengsir@gmail.com>
     */
    private checkProjectSize(projectPath: string): void {
        try {
            const fs = require('fs');
            const path = require('path');
            
            let fileCount = 0;
            const maxCheckFiles = this.LARGE_PROJECT_THRESHOLD + 1000; // 避免无限检查
            
            const countFiles = (dir: string, depth: number = 0): void => {
                if (fileCount > maxCheckFiles || depth > this.MAX_WATCH_DEPTH) {
                    return;
                }
                
                try {
                    const items = fs.readdirSync(dir, { withFileTypes: true });
                    
                    for (const item of items) {
                        if (fileCount > maxCheckFiles) break;
                        
                        const fullPath = path.join(dir, item.name);
                        
                        // 跳过常见的大目录
                        if (item.isDirectory()) {
                            if (['node_modules', '.git', 'dist', 'build', '.next', '.nuxt'].includes(item.name)) {
                                continue;
                            }
                            countFiles(fullPath, depth + 1);
                        } else {
                            fileCount++;
                        }
                    }
                } catch (error) {
                    // 忽略权限错误等
                }
            };
            
            countFiles(projectPath);
            
            this.isLargeProject = fileCount > this.LARGE_PROJECT_THRESHOLD;
            this.logger.info(`项目文件数量检查完成: ${fileCount}个文件，${this.isLargeProject ? '大项目' : '普通项目'}`, 'FileWatcher');
            
        } catch (error) {
            this.logger.warn(`项目大小检查失败: ${error}`, 'FileWatcher');
            this.isLargeProject = false;
        }
    }
    
    /**
     * 启动内存监控
     * @author lihengtt <lihengsir@gmail.com>
     */
    private startMemoryMonitoring(): void {
        // 每30秒检查一次内存使用情况
        this.memoryCheckInterval = setInterval(() => {
            this.checkMemoryUsage();
        }, 30000);
        
        // 立即执行一次检查
        this.checkMemoryUsage();
    }
    
    /**
     * 检查内存使用情况
     * @author lihengtt <lihengsir@gmail.com>
     */
    private checkMemoryUsage(): void {
        try {
            const memUsage = process.memoryUsage();
            const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
            const heapTotalMB = Math.round(memUsage.heapTotal / 1024 / 1024);
            const rssMB = Math.round(memUsage.rss / 1024 / 1024);
            
            // 记录内存使用情况（每5分钟记录一次，避免日志过多）
            const now = Date.now();
            if (now - this.lastMemoryCheck > 300000) { // 5分钟
                this.logger.info(`内存使用情况 - 堆内存: ${heapUsedMB}/${heapTotalMB}MB, RSS: ${rssMB}MB, 监控文件: ${this.watchedFileCount}`, 'FileWatcher');
                this.lastMemoryCheck = now;
            }
            
            // 如果内存使用过高，发出警告
            if (heapUsedMB > 200) { // 超过200MB
                this.logger.warn(`内存使用过高: ${heapUsedMB}MB，建议关闭自动同步`, 'FileWatcher');
                
                if (heapUsedMB > 500) { // 超过500MB，强制停止
                    this.logger.error(`内存使用严重过高: ${heapUsedMB}MB，自动停止文件监控`, 'FileWatcher');
                    vscode.window.showErrorMessage(`文件监控内存使用过高（${heapUsedMB}MB），已自动停止以保护系统稳定性。`);
                    this.stop();
                }
            }
            
            // 如果同步队列过大，清理部分队列
            if (this.syncQueue.length > this.MAX_SYNC_QUEUE_SIZE * 0.8) {
                this.logger.warn(`同步队列过大 (${this.syncQueue.length})，清理部分队列`, 'FileWatcher');
                // 只保留最新的一半文件
                this.syncQueue = this.syncQueue.slice(-Math.floor(this.MAX_SYNC_QUEUE_SIZE / 2));
            }
        } catch (error) {
            this.logger.error(`检查内存使用时出错: ${error}`, 'FileWatcher');
        }
    }
}